home *** CD-ROM | disk | FTP | other *** search
/ 1,000+ Great Games / 1_1000 Games.iso / DOSGAMES / POLYINIT.ZIP / POLYLIB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-28  |  7.6 KB  |  438 lines
  1. #pragma inline
  2. #include <conio.h>
  3. #include <stdio.h>
  4.  
  5.  
  6. extern long *SIN, *COS;
  7. int xtrans, ytrans, ztrans;
  8. int xang, yang, zang;
  9. long scal;
  10.  
  11. typedef struct
  12. {
  13.     int x,y;
  14. } VERTEX_2D;
  15.  
  16. typedef struct
  17. {
  18.     int color, lados, ptr;
  19.     VERTEX_2D *vertice;
  20. } POL_2D;
  21.  
  22. typedef struct
  23. {
  24.     int x,y,z;
  25. } VERTEX_3D;
  26.  
  27. typedef struct
  28. {
  29.     int vis, lados, color, ptr, norm_ptr;
  30. } POL_3D;
  31.  
  32. typedef struct
  33. {
  34.     int num_of_pols, num_of_ptrs,num_of_verts;
  35.     int pointer_ptr, vertice_ptr;
  36.     POL_3D far *pol;
  37.     int far *pointer;
  38.     VERTEX_3D far *vertice;
  39. } OBJECT;
  40.  
  41. int zmin[100]; //z's para el sorting
  42. /********************FUNCIONES PARA OBJETOS COMPLETOS***********************/
  43.  
  44. void swap_P3D( POL_3D far *pol, int a, int b )
  45. {
  46.     a*=10;
  47.     b*=10;
  48.     asm{
  49.         les di,pol
  50.         mov dx,di
  51.         add di,a
  52.  
  53.         mov eax,es:di
  54.         mov ebx,es:[di+4]
  55.         mov cx,es:[di+8]
  56.  
  57.         mov di,dx
  58.         add di,b
  59.         xchg es:di,eax
  60.         xchg es:[di+4],ebx
  61.         xchg es:[di+8],cx
  62.         mov di,dx
  63.         add di,a
  64.         mov es:di,eax
  65.         mov es:[di+4],ebx
  66.         mov es:[di+8],cx
  67.     };
  68. }
  69.  
  70. void swapint( int far *a, int far *b )
  71. {
  72.     asm{
  73.         mov ax,[a]
  74.         xchg ax,[b]
  75.     };
  76. }
  77.  
  78. void sortpoly( OBJECT far *object, POL_3D far *polys,
  79.                     int far *pointers, VERTEX_3D far *vertex )
  80. {   int cuenta, cuenta1, cuenta2, lados;
  81.     int ptr0, ptr1, pols, numpol, z;
  82.  
  83. //  ACCESO AL OBJETO
  84.     asm{   //obtener el numero de polígonos
  85.         les di,object
  86.         mov ax,es:di
  87.         mov numpol,ax
  88.     };
  89.  
  90.     cuenta1=0;
  91. //ACCESO A LOS POL╓GONOS
  92. looper1:
  93.     asm{
  94.         mov bx,cuenta1
  95.         mov ax,10
  96.         mul bl
  97.         les di,polys
  98.         add di,ax
  99.         mov ax,es:[di+6]
  100.         mov ptr0,ax
  101.         mov ax,es:[di+2]
  102.         mov lados,ax
  103.     };
  104. //GETMINZ para un polígono
  105.     for( cuenta=0, z=-32000; cuenta<lados; cuenta++)
  106.     {
  107.         ptr1=pointers[ptr0+cuenta];
  108.         if(    vertex[ptr1].z > z )
  109.             z=vertex[ptr1].z;
  110.     };
  111.  
  112.     zmin[cuenta1]=z;
  113.     cuenta1++;
  114.  
  115.     if(cuenta1<numpol)
  116.         goto looper1;
  117.  
  118. //SORTPOLYS poner en orden todos los polígonos
  119.     cuenta1=0;
  120.     while(cuenta1<numpol)
  121.     {
  122.         for( cuenta2=cuenta1+1; cuenta2<numpol; cuenta2++)
  123.             if(zmin[cuenta1] <= zmin[cuenta2])
  124.             {
  125.                 swap_P3D( polys, cuenta1, cuenta2 );
  126.                 swapint((int far *)&zmin[cuenta1], (int far *)&zmin[cuenta2]);
  127.             };
  128.         cuenta1++;
  129.     };
  130. }
  131.  
  132. void getpoly( POL_3D far *list, int far *vertxlist,
  133.                     VERTEX_2D far *polylist,
  134.                         VERTEX_2D far *salida, int far *col,
  135.                             int far *sides, int numpol )
  136. {   int cuenta, ptr0, ptr1, lados, color;
  137.  
  138. //    ptr=list[numpol].ptr;
  139.     asm{
  140.         mov bx,numpol
  141.         mov ax,10
  142.         mul bl
  143.         les di,list
  144.         add di,ax
  145.         mov ax,es:[di+6]
  146.         mov ptr0,ax
  147.         mov ax,es:[di+4]
  148.         mov color,ax
  149.         mov ax,es:[di+2]
  150.         mov lados,ax
  151.     };
  152.  
  153.     sides[0]=lados;
  154.     col[0]=color;
  155.  
  156.     for( cuenta=0; cuenta<lados; cuenta++)
  157.     {
  158.         ptr1=vertxlist[ptr0+cuenta];
  159.  
  160.         salida[cuenta].x=polylist[ptr1].x;
  161.         salida[cuenta].y=polylist[ptr1].y;
  162.     };
  163. }
  164.  
  165. void getpoly_3D( POL_3D far *list, int far *vertxlist,
  166.                     VERTEX_3D far *polylist,
  167.                         VERTEX_3D far *salida, int numpol )
  168. {   int cuenta, ptr0, ptr1, lados, color;
  169.  
  170. //    ptr=list[numpol].ptr;
  171.     asm{
  172.         mov bx,numpol
  173.         mov ax,10
  174.         mul bl
  175.         les di,list
  176.         add di,ax
  177.         mov ax,es:[di+6]
  178.         mov ptr0,ax
  179.         mov ax,es:[di+4]
  180.         mov color,ax
  181.         mov ax,es:[di+2]
  182.         mov lados,ax
  183.     };
  184.  
  185.  
  186.     for( cuenta=0; cuenta<lados; cuenta++)
  187.     {
  188.         ptr1=vertxlist[ptr0+cuenta];
  189.  
  190.         salida[cuenta].x=polylist[ptr1].x;
  191.         salida[cuenta].y=polylist[ptr1].y;
  192.         salida[cuenta].z=polylist[ptr1].z;
  193.     };
  194. }
  195.  
  196.  
  197. /**********************FUNCIONES PARA 3 DIMENSIONES*************************/
  198. /*
  199. void getnormals( *POL_3D far *list, int far *vertxlist,
  200.                     VERTEX_3D far *polylist,
  201.                         VERTEX_3D far *buffer,
  202.                             VERTEX_3D far *salida, int pols )
  203. {   int cuenta, dummy;
  204.  
  205.     for( cuenta=0; cuenta<pols; cuenta++ )
  206.     {
  207.         getpoly_3D( list, vertxlist, polylist, buffer, int cuenta );
  208.  
  209.  
  210.  
  211.  
  212.  
  213. */
  214. void rotate( VERTEX_3D far *pol, int lados, int xang, int yang, int zang )
  215. {    int cuenta;
  216.     long bufferx, buffery, bufferz, seno, coseno, x, y, z;
  217.  
  218.     for(cuenta=0; cuenta<=lados; cuenta++)
  219.     {
  220.         seno=SIN[xang&255];
  221.         coseno=COS[xang&255];
  222.  
  223.         buffery=(long)pol[cuenta].y;
  224.         bufferz=(long)pol[cuenta].z;
  225.  
  226.         buffery*=coseno;
  227.         bufferz*=seno;
  228.         buffery-=bufferz;
  229.         buffery>>=16;
  230.         y=buffery;
  231.  
  232.         buffery=(long)pol[cuenta].y;
  233.         bufferz=(long)pol[cuenta].z;
  234.         buffery*=seno;
  235.         bufferz*=coseno;
  236.         buffery+=bufferz;
  237.         buffery>>=16;
  238.         pol[cuenta].y=(int)y;
  239.         pol[cuenta].z=(int)buffery;
  240.  
  241.         seno=SIN[yang&255];
  242.         coseno=COS[yang&255];
  243.  
  244.         bufferx=(long)pol[cuenta].x;
  245.         bufferz=(long)pol[cuenta].z;
  246.  
  247.         bufferx*=coseno;
  248.         bufferz*=seno;
  249.         bufferx-=bufferz;
  250.         bufferx>>=16;
  251.         x=bufferx;
  252.  
  253.         bufferx=(long)pol[cuenta].x;
  254.         bufferz=(long)pol[cuenta].z;
  255.         bufferx*=seno;
  256.         bufferz*=coseno;
  257.         bufferx+=bufferz;
  258.         bufferx>>=16;
  259.         pol[cuenta].x=(int)x;
  260.         pol[cuenta].z=(int)bufferx;
  261.  
  262.         seno=SIN[zang&255];
  263.         coseno=COS[zang&255];
  264.  
  265.         bufferx=(long)pol[cuenta].x;
  266.         buffery=(long)pol[cuenta].y;
  267.  
  268.         bufferx*=coseno;
  269.         buffery*=seno;
  270.         bufferx-=buffery;
  271.         bufferx>>=16;
  272.         x=bufferx;
  273.  
  274.         bufferx=(long)pol[cuenta].x;
  275.         buffery=(long)pol[cuenta].y;
  276.         bufferx*=seno;
  277.         buffery*=coseno;
  278.         bufferx+=buffery;
  279.         bufferx>>=16;
  280.         pol[cuenta].x=(int)x;
  281.         pol[cuenta].y=(int)bufferx;
  282.  
  283.     };
  284. }
  285.  
  286. void translate( VERTEX_3D far *pol, int lados, int xt, int yt, int zt )
  287. {   int cuenta;
  288.     for( cuenta=0; cuenta<=lados; cuenta++)
  289.     {
  290.         pol[cuenta].x+=xt;
  291.         pol[cuenta].y+=yt;
  292.         pol[cuenta].z+=zt;
  293.     };
  294. }
  295.  
  296. void z_persp( VERTEX_3D far *pol, int lados )
  297. {   int cuenta;
  298.     long x, y, z, cons;
  299.     for(cuenta=0; cuenta<=lados; cuenta++)
  300.     {
  301.         z=(long)pol[cuenta].z; //xo=x-x*(z/(z+256))
  302.         if(z<-300L)
  303.         {
  304. //            printf("Z demasiado grande");
  305.             return;
  306.         };
  307.         cons=z;
  308.         cons<<=16;
  309.         cons/=(z+600);
  310.         x=(long)pol[cuenta].x;
  311.         x*=cons;
  312.         x>>=16;
  313.         y=(long)pol[cuenta].y;
  314.         y*=cons;
  315.         y>>=16;
  316.         pol[cuenta].x-=(int)x;
  317.         pol[cuenta].y-=(int)y;
  318.     };
  319. }
  320.  
  321. void zoom( VERTEX_3D far *pol, int lados )
  322. {   int cuenta;
  323.     long x, y, z;
  324.  
  325.     for(cuenta=0; cuenta<=lados; cuenta++ )
  326.     {
  327.         x=(long)pol[cuenta].x;
  328.         x*=scal;
  329.         x>>=16;
  330.         y=(long)pol[cuenta].y;
  331.         y*=scal;
  332.         y>>=16;
  333.         pol[cuenta].x=(int)x;
  334.         pol[cuenta].y=(int)y;
  335.     };
  336. }
  337.  
  338. void copypoly3d( VERTEX_3D far *origen, VERTEX_3D far *destino, int lados )
  339. {
  340.     asm{
  341.         mov cx,lados
  342.         mov bx,cx
  343.         add bx,cx
  344.         add bx,cx
  345.         push ds
  346.         lds si,origen
  347.         les di,destino
  348.         mov cx,1
  349.         and cx,bx  //numero de bytes excedentes
  350.         rep movsw
  351.         mov cx,bx
  352.         shr cx,1
  353.         rep movsd //dos palabras por vez
  354.         pop ds
  355.     };
  356. }
  357.  
  358. void copy3to2d( VERTEX_3D far *orig, VERTEX_2D far *dest, int lados )
  359. {
  360.     asm{
  361.         mov cx,lados
  362.         push ds
  363.         lds si,orig
  364.         les di,dest
  365.     };
  366. label:
  367.     asm{
  368.         movsd
  369.         add si,2
  370.         loop label
  371.         pop ds
  372.     };
  373. }
  374.  
  375. /**********************FUNCIONES PARA DOS DIMENSIONES***********************/
  376.  
  377. void polyclip( VERTEX_2D far *pol, int lados )
  378. {   int cuenta;
  379.  
  380.     for( cuenta=0; cuenta<=lados; cuenta++ )
  381.     {
  382.         if(pol[cuenta].x>319)
  383.             pol[cuenta].x=319;
  384.         if(pol[cuenta].x<0)
  385.             pol[cuenta].x=0;
  386.         if(pol[cuenta].y>199)
  387.             pol[cuenta].y=199;
  388.         if(pol[cuenta].y<0)
  389.             pol[cuenta].y=0;
  390.     };
  391. }
  392.  
  393. void copypoly2d( VERTEX_2D far *origen, VERTEX_2D far *destino, int lados )
  394. {
  395.     asm{
  396.         mov cx,lados
  397.         push ds
  398.         lds si,origen
  399.         les di,destino
  400.         rep movsd //dos palabras por vez
  401.         pop ds
  402.     };
  403. }
  404.  
  405. void mat2vid( VERTEX_2D far *verts, int lados )
  406. {
  407.     asm mov cx,lados
  408.     asm les di,verts
  409. inicio:
  410.     asm{
  411.         mov eax,es:di
  412.         add ax,160
  413.         rol eax,16
  414.         add ax,100
  415.         rol eax,16
  416.         stosd
  417.         loop inicio
  418.     };
  419. }
  420.  
  421. void mat2vid_3D( VERTEX_3D far *verts, int lados )
  422. {
  423.     asm mov cx,lados
  424.     asm les di,verts
  425. inicio:
  426.     asm{
  427.         mov eax,es:di
  428.         add ax,160
  429.         rol eax,16
  430.         add ax,100
  431.         rol eax,16
  432.         stosd
  433.         add di,2
  434.         loop inicio
  435.     };
  436. }
  437.  
  438.